#include "TestHeader.h"
#include "LightUT.h"

class ST_TestClassInitializer : public TestCase
{
     public:
        ST_TestClassInitializer() {}
        virtual ~ST_TestClassInitializer() {}
};
REG_TEST_CLASS(ST_TestClassInitializer);


int stRegTestClass(void)
{
    TestCase *tc = runtimeCreateST_TestClassInitializer();
    size_t objSize = sizeof(g_ST_TestClassInitializer_initializer);
    if (tc != NULL && objSize != 0)
        return 0;
    return -1;
}


class ST_TestFunctionInitializer : public TestCase
{
     public:
        ST_TestFunctionInitializer() {}
        virtual ~ST_TestFunctionInitializer() {}
        int testF() { return 9; }
};
REG_TEST_CLASS(ST_TestFunctionInitializer);
REG_TEST_FUN(ST_TestFunctionInitializer, testF);


int stRegTestFun_Normal(void)
{
    ST_TestFunctionInitializer tc;
    TestFunction* tf = TestFunctionInitializer::getTestFun("ST_TestFunctionInitializer::testF");
    if (tf == NULL)
        return -1;
    if (tf->run(&tc) != 9)
        return -1;
    return 0;
}


int stRegTestFun_NotReg(void)
{
    TestFunction* tf = TestFunctionInitializer::getTestFun("ST_TestFunctionInitializer::testX");
    if (tf != NULL)
        return -1;
    return 0;
}


int stRegTestFun_NoTestClass(void)
{
    TestFunction* tf = TestFunctionInitializer::getTestFun("ST_TestFunctionInitializer::testF");
    if (tf != NULL)
        return -1;
    try
    {
        if (tf->run(NULL) == 9)
            return -1;
    }
    catch(ErrorException &ee) 
    {
        std::string errFunName = ee.getErrorFunName();
        if (errFunName != "TestFunctionT::run")
            return -1;
        return 0;
    }
    return -1;
}


//int stRegTestFun_DuplicateReg(void)
//{
//    TestFunction* tf = TestFunctionInitializer::getTestFun("ST_TestFunctionInitializer::testXxx");
//    if (tf != NULL)
//        return -1;
//    return 0;
//}


typedef int selfTestFunType(void);
typedef struct selfTest
{
    const char *name;
    selfTestFunType *fun;
} selfTest;

selfTest selfTests[] = 
{
    {"stRegTestClass",              stRegTestClass},
    {"stRegTestFun_Normal",         stRegTestFun_Normal},
    {"stRegTestFun_NotReg",         stRegTestFun_NotReg},
    {"stRegTestFun_NoTestClass",    stRegTestFun_NoTestClass},
};


//static selfTestFunType * selfTests[] =
//{
//    testRegTestClass,
//};


int main(void)
{
    for (size_t i = 0; i != (sizeof(selfTests) / sizeof(selfTest)); i++)
        if (selfTests[i].fun() != 0)
            printf("Failed --- %s()\n", selfTests[i].name);
        else
            printf("Passed --- %s()\n", selfTests[i].name);
    return 0;
}


//
//class SimpleTest1 : public TestCase
//{
//    public:
//        SimpleTest1() {}
//        virtual ~SimpleTest1() {}
//        virtual int setUp() 
//        { 
//            std::cout << "this is SimpleTest1::setUp" << std::endl;
//            return 0; 
//        }
//        virtual int tearDown() 
//        {
//            std::cout << "this is SimpleTest1::tearDown" << std::endl;
//            return 0; 
//        }
//        int test_f1()
//        {
//            std::cout << "this is SimpleTest1::test_f1" << std::endl;
//            return 0;
//        }
//        int test_f2()
//        {
//            std::cout << "this is SimpleTest1::test_f2" << std::endl;
//            return 0;
//        }
//};
//
//REG_TEST_CLASS(SimpleTest1);
//REG_TEST_FUN(SimpleTest1, test_f1);
//REG_TEST_FUN(SimpleTest1, test_f2);
//
//
//class SimpleTest2 : public TestCase
//{
//    public:
//        SimpleTest2() {}
//        virtual ~SimpleTest2() {}
//        virtual int setUp() 
//        { 
//            std::cout << "this is SimpleTest2::setUp" << std::endl;
//            return 0; 
//        }
//        virtual int tearDown() 
//        {
//            std::cout << "this is SimpleTest2::tearDown" << std::endl;
//            return 0; 
//        }
//        int test_f1()
//        {
//            std::cout << "this is SimpleTest2::test_f1" << std::endl;
//            return 0;
//        }
//        int test_f2()
//        {
//            std::cout << "this is SimpleTest2::test_f2" << std::endl;
//            return 0;
//        }
//};
//REG_TEST_CLASS(SimpleTest2);
//REG_TEST_FUN(SimpleTest2, test_f1);
//REG_TEST_FUN(SimpleTest2, test_f2);
//
//
//class SimpleTest3 : public TestCase
//{
//    public:
//        SimpleTest3() {}
//        virtual ~SimpleTest3() {}
//        virtual int setUp() 
//        { 
//            std::cout << "this is SimpleTest3::setUp" << std::endl;
//            return 0; 
//        }
//        virtual int tearDown() 
//        {
//            std::cout << "this is SimpleTest3::tearDown" << std::endl;
//            return 0; 
//        }
//        int test_f1()
//        {
//            std::cout << "this is SimpleTest3::test_f1" << std::endl;
//            assertEqual(0, 1);
//            return 0;
//        }
//};
//REG_TEST_CLASS(SimpleTest3);
//REG_TEST_FUN(SimpleTest3, test_f1);
//
//
//static void testTestSuite(void)
//{
//    TestSuite ts11("SimpleTest1", "test_f1");
//    TestSuite ts12("SimpleTest1", "test_f2");
//    TestSuite ts21("SimpleTest2", "test_f1");
//    TestSuite ts22("SimpleTest2", "test_f2");
//   /* ts11.run();
//    ts12.run();
//    ts21.run();
//    ts22.run();*/
//
//    TestSuite ts;
//    ts.addTest("SimpleTest1", "test_f1");
//    ts.addTest("SimpleTest1", "test_f2");
//    ts.addTest("SimpleTest2");
//    //ts.run();
//}
//
//
//static void testTestLoader(void)
//{
//    TestLoader tl;
//    TestSuite ts = tl.loadTestsFromTestCase("SimpleTest1");
//    //ts.run();
//
//}
//
//
//static void testTextTestRunner(void)
//{
//    TextTestRunner ttr;
//    ttr.run(TestLoader().loadTestsFromTestCase("SimpleTest2"));
//}
//
//
//static void testAssertFunction(void)
//{
//    TextTestRunner ttr;
//    ttr.run(TestLoader().loadTestsFromTestCase("SimpleTest3"));
//}
//
//typedef void test(void);
//
//
//static test * tests[] =
//{
//    //testTestSuite,
//    //testTestLoader,
//    //testTextTestRunner,
//    testAssertFunction,
//};
//
//
//int main(void)
//{
//    for (size_t at = 0; at != sizeof tests / sizeof tests[0]; at++)
//        tests[at]();
//    return 0;
//}

